大多数卡片轮播只是把卡片排成一行,然后横向平移。景深环形卡片不一样:它把整排卡片卷成一个环,再让摄像机站在环内或环外。

看起来像两种完全不同的效果,其实只是同一个环、同一台摄像机、同一套材质在两个位置上的结果。空间感不是靠多加几层阴影,而是靠几何、透视、模糊和动效服从同一个真相。

先把它当成一只环,而不是一排卡片

先把参数定下来:

  • 卡片数量 N = 22;
  • 每张卡片 180 × 300;
  • 卡片间距 gap = 18;
  • 沿弧线相邻两张卡片的步长 step = 180 + 18 = 198;
  • 环的半径 R = N × step / (2π) ≈ 693。

半径不是随手写的,而是由卡片数量和步长推出来的。这样环的周长恰好等于整排卡片的长度,首尾才能严丝合缝地接上。

第 i 张卡片在弧线上的位置是:

1
s = wrap(i × step - offset)

offset 表示整排卡片已经移动了多远;最前面的卡片是 round(offset / step) mod N。用户拖动时,改变的是 offset,不是逐张修改每张卡片的位置。

接下来用一个有符号曲率,把整排卡片同时放到弧线上:

1
2
3
4
5
6
7
8
9
10
11
c = bend / R

当 c = 0:
x = s
z = 0
a = 0

当 c ≠ 0:
a = s × c
x = sin(a) / c
z = (1 - cos(a)) / c

x 横向展开,z 朝向观察者,卡片绕自己的竖直中轴旋转 a。bend = 1 是环内视角,环向观察者弯曲;bend = -1 是环外视角,环向远处弯曲。

切换视角时,不要直接跳变。让 bend 在 1100ms 内用 cubic-bezier(0.65, 0, 0.35, 1) 从一端过渡到另一端,整排卡片就会肉眼可见地从一个环弯成另一个环。

两个视角,是同一台摄像机的两个位置

环内和环外的差别,主要来自摄像机离正面卡片有多远。

1
P = mix(pIn, pOut, (1 - bend) / 2)

P 是眼睛到正面卡片的距离。bend = 1 时 P = pIn,bend = -1 时 P = pOut。

  • 环内:pIn = 860px。眼睛略在环心后方,两侧卡片会靠近、变大,一屏大约看到五张:三张完整,外侧两张进入玻璃边。
  • 环外:pOut = 1500px。眼睛退到环外,以平视角度看整只环;正前方的卡片清晰,两侧和远端逐渐模糊、淡化。

投影仍然是最普通的透视投影。一个点 (x, y, z) 落在屏幕上的位置是:

1
2
screenX = x × P / (P - z)
screenY = y × P / (P - z)

如果卡片的任何部分离眼睛不到 140 个单位,或者整张卡片完全在画面外,就不画它。环内视角下,22 张卡片里通常只有五张需要参与绘制;环外才会看到整只环。

pIn = 860 不是随便挑的。它比环半径 693 略大,眼睛因此比环心再往后退约 167 个单位;这样两侧卡片仍会靠近镜头,但不会被拉得过大。pOut = 1500 则退得足够远,让环转向远处的动作显得平缓。

卡片的边、面和深度

卡片不能用普通圆角矩形。这里用的是指数为 4 的超椭圆,圆角半径 32px,对应 CSS corner-shape: superellipse(2) 的连续曲率。它的边不会在直线和圆弧的接缝处突然改变方向,所以卡片转到侧面时,轮廓仍然顺滑。

正面是四色流动渐变,背面是图片。图片要预先镜像,这样卡片翻过去之后,内容才是正的。

一个反直觉的细节:不要给卡片加阴影、反射,也不要在它转离视线时压暗。 在白色页面上,这些效果不会制造深度,只会让卡片看起来脏。深度应该来自尺寸、模糊和淡出,而不是一层灰色。

按下卡片时,它在 140ms 内缩到 0.95,松开后 320ms 恢复,缩放围绕卡片中心。这个小反馈不需要弹簧,也不需要夸张的回弹;它只是告诉用户“按到了”。

流体渐变:让颜色缓慢流动,但循环不跳

渐变不是两张静态色块在交叉淡化,而是一个连续的噪声场。

用值噪声做 fBm,取 3 个倍频程。每次叠加前,把采样点旋转、缩放、平移,再把振幅减半:

1
2
3
matrix = (0.8, -0.6; 0.6, 0.8)
scale = 2.02
offset = (1.7, 9.2)

每张卡片用不同的种子:

1
2
uv   = p / w × 0.9 + seed
seed = i × 3.7 + 0.43

p 是卡片上以像素为单位、从中心起算的坐标。这样 22 张卡片的纹理不会完全一样,但也不会花花绿绿到失控。

接下来做两次域扭曲:

1
2
3
4
w1 = (fbm(uv + o1), fbm(uv + (5.2, 1.3) - o1))
w2 = (fbm(uv + 1.5 × w1 + (1.7, 9.2) + o2),
fbm(uv + 1.5 × w1 + (8.3, 2.8) - o2))
f = fbm(uv × 0.9 + 1.7 × w2)

颜色从四个色标里混合出来:先用 f 在 c0 和 c1 之间过渡,再让 w2.x 和 w1.y 分别把颜色推向 c2、c3。顶部加一层很轻的高光,最后叠上约 ±1.75% 的胶片颗粒。颗粒在模糊下会自然消失,不会变成噪点。

关键是流动方式。不要让噪声场线性平移,否则循环回到起点时一定会跳。让场沿一个圆运动:

1
2
o1 = rho × (cos(phi), sin(phi))
o2 = rho × (cos(phi + 2.1), sin(phi + 2.1))

phi 随时间增长,场每秒移动约 0.2 个噪声单元。因为它是绕圆运动,转完一圈会回到起点,所以录屏或循环播放都不会出现接缝。演示里一圈正好是 17.07 秒,也就是动画循环的长度。

玻璃边:不是模糊,是折射

环内视角两侧的玻璃边,不是给卡片加一层高斯模糊。它是一层真正参与成像的玻璃。

做法分两遍:

  1. 先把所有卡片画进一张纹理;
  2. 再把这张纹理贴到屏幕上,并在两侧各 160px 的范围内做折射。

设某个像素离画面边缘的距离为 d,d < rim 时:

1
2
k = (1 - d / rim) ^ 2.4
offset = 0.4 × rim × k

这个偏移沿着“指向画面中心、同时指向眼睛高度”的方向取样,所以卡片靠近玻璃时,上下边缘会向外张开,而不是像被剪刀裁掉。

0.4 × 2.4 必须小于 1。否则玻璃会把画面折回自身,出现重复的卡片或重复的间隙。这个约束不是审美偏好,而是几何上不能越过的线。

色散用七次采样模拟:红光偏得最远,蓝光偏得最少。

1
2
3
spread = 0.25 × k
offset_i = offset × (1 + spread × (1 - 2t))
t = i / 6, i = 0..6

每个样本用一组权重混合,权重之和归一化,色边才会平滑地穿过颜色,而不是出现七条硬边。玻璃上再加一层很淡的高光,强度约为 k³ × 0.12。

玻璃边只属于环内视角。bend 靠近 0 时,它要跟着淡出;rim = 0 时完全关闭。

环外景深:逐像素,而不是 backdrop-filter

环外视角的模糊有两个来源:横向位置和前后深度。

1
2
3
横向模糊 = blur × smoothstep(110, 画面半宽, |screenX|) ^ 1.4
深度模糊 = blur × smoothstep(0.25, 0.8, back) ^ 1.2
back = -z / (2R)

画面中间 220px 保持清晰,越往两侧越模糊;back 从正面卡片的 0 增长到远端卡片的 1,越靠后越模糊。默认 blur = 14px。

不要用 backdrop-filter 盖在运动的卡片上。卡片在动,背景模糊会跟着闪烁;而且它只能模糊背景,不能表达“这张卡片本身离焦”。

正确做法是逐像素计算,并且给每张卡片单独算覆盖范围。一张卡片在屏幕上的左右边界分别是 dl、dr,横向覆盖率可以写成:

1
across = clamp((min(dl, b) + min(dr, b)) / (2b), 0, 1)

上下方向同理,最后把两个方向的覆盖率相乘,再用圆角做柔化。比模糊半径还窄的卡片永远不会达到完全不透明,它会自然淡出,就像真实镜头里的失焦。

每张卡片绘制时,四周要留出“最大模糊半径 + 4px”的余量,否则模糊边缘会被裁掉。卡片内容也要跟着模糊:高频的噪声倍频逐渐淡出,图片从分辨率更低的 mipmap 层级读取。远端再向页面颜色淡出,默认 50%。

翻面、拖拽和惯性

从环内切到环外时,卡片会依次翻面。

整段翻面持续 1800ms,使用 cubic-bezier(0.3, 0, 0.6, 1)。每张卡片的延迟与它离正面的距离有关:

1
2
lag  = min(|s| / (6 × step), 1)
turn = π × smoothstep(0, 1, flip × 1.55 - lag × 0.55)

所以翻面从正前方的卡片开始,向两侧扩散。前半圈最后露出图片,后半圈仍然保持渐变;切回环内时再反向翻回去。

拖拽是一比一跟手的:指针移动多少像素,整排卡片就移动多少。松手后不立刻停住,而是带着释放速度继续滑一段:

1
target = offset - velocity × 260ms

然后吸附到最近的卡片。滑动时长按距离计算,并夹在 420–1100ms 之间,曲线用 cubic-bezier(0.25, 0.6, 0.2, 1)。按下某张卡片时,它在 760ms 内转到正前方。

还有一种“硬甩”动画,用来从环外快速打开环内:16 张卡片在 2800ms 内依次经过,曲线用 cubic-bezier(0.4, 0, 0.12, 1)。它会在很短的时间里加速,而不是瞬间跳到最高速,所以循环播放时不会在开头抖一下。

任何新动作都要停止上一个动作。减少动态效果时,关闭渐变流动,视角切换改为瞬时,滑动最多 200ms。

参数面板是设计的一部分

把关键数值做成滑块,不是为了炫技,而是为了让“手感”可以被讨论。

视角 参数 默认值 范围
环内 透视 860px 600–1400
环内 玻璃边 160px 0–240
环内 色散 25% 0–60
环内 流速 20% 0–60
环内 圆角 32px 0–60
环外 透视 1500px 900–2400
环外 景深模糊 14px 0–30
环外 远端淡出 50% 0–100
环外 流速 20% 0–60
环外 圆角 32px 0–60

滑块一动,画面立即更新,同时停止演示动画。重置按钮把所有值恢复默认。

流速的实现要注意:每帧增加的是流动角度,而不是把时间乘进噪声坐标。否则用户拖动滑块时,渐变会突然跳一大段。

实现路径

Web:用 WebGL 2 做两遍渲染。每张卡片是一排竖直的列(约 96 列,左右各多一列作为余量),在顶点着色器里放到弧线上;竖直的线在透视下仍然是直线,所以每列只需要上下两个点。图片放进一张带 mipmap 的纹理数组。先按从远到近的顺序,用预乘 alpha 把卡片画进纹理,再做玻璃遍输出到屏幕。一个 requestAnimationFrame 循环驱动全部动画。

iOS:用 Metal(MTKView)复用同样的两遍渲染;也可以用 SwiftUI 的 Metal [[stitchable]] layer effect 做玻璃遍,用 visualEffect 处理卡片。

Android:OpenGL ES 3 或 Vulkan;API 33+ 可以用 AGSL RuntimeShader 在 Compose 里画渐变和玻璃遍。

Flutter:用 FragmentProgram 做着色器,卡片用 CustomPainter 配合 drawVertices。

没有 GPU 路径时:用 CSS 3D transform 按同样的 x、z、a 摆放卡片,用 CSS 渐变代替流体;省掉玻璃遍,用几层阶梯式模糊模拟景深。效果会弱一些,但几何关系仍然成立。

检查清单

  • 环内:外侧卡片在玻璃边里平滑张开,有柔和色边,没有折叠或重复的卡片,一屏五张。
  • 环外:像一只平视的环,中间清晰,模糊向两侧和远端平滑增加,转动时没有闪烁,斜到侧面的卡片没有硬边。
  • 翻面从中间向两侧发生,图片方向正确,远端仍然显示渐变。
  • 每个滑块都能即时改变画面,数值与默认表一致,重置能恢复全部参数。
  • 拖拽一比一跟手,松手后有惯性并吸附到最近卡片,快速甩动不会跳帧。
  • 减少动态效果、浅色 / 深色页面、键盘操作参数面板都检查过。
  • 在中端手机上接近 60fps;不可见时停止渲染。

景深环形卡片 Prompt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
Prompt

Build a ring of cards in my project, in two views. Inside: the viewer stands in the
middle of the ring, the cards near the edges come closer and grow, and they pass under
a rim of glass at each side of the frame that bends them and splits their colors.
Outside: the ring is seen at eye level from outside, the front card is in focus, the
sides and the far side soften with distance, and switching to it turns the cards over,
one after another, from flowing gradients to pictures. Every card's gradient flows
slowly. A settings panel shows the key numbers as sliders, set to the defaults below,
so they can be tuned live.

Every value here comes from a working demo and is the default, not a requirement. Build
it with these values first, then let me tune them with the panel (section 8).

Before building, look at my project (section 0) and ask me these, one at a time, with
the recommended answer marked:
1. Where it goes: its own page or section (recommended), or a component I name.
2. What the cards hold: flowing gradients on the front and my pictures on the back
(recommended; tell me where the pictures come from), gradients only, or pictures only
(then skip the turn-over and show the pictures in both views).
3. The view it opens in: Inside (recommended) or Outside, and whether people can switch
(a two-option segmented control, recommended).
4. The settings panel: shown to everyone, shown only in development, or hidden behind a
toggle.
Then sum up my answers, say how you will build it on my platform (section 9), and wait
for my go-ahead.

0. Start from what exists
- Find how the project draws (DOM, canvas or WebGL, a native view tree, a GPU renderer),
its framework and versions, where the pictures live, its slider or form components,
and whether it has a dark mode and a reduced-motion setting.
- Tell me in a few lines what you found before asking.

1. The ring
- N cards of w x h, a gap between them, one step = w + gap apart along an arc. Default:
N = 22, 180 x 300, gap 18, so step 198 and radius R = N * step / (2 * PI) ≈ 693. The
ring's circumference is exactly the row, so it closes on itself.
- Each card i sits at s = wrap(i * step - offset) along the arc, wrapped into [-N * step
/ 2, N * step / 2). offset is how far the row has moved; the front card is
round(offset / step) mod N.
- One signed curvature c = bend / R places every card: for c = 0, x = s, z = 0, a = 0;
otherwise a = s * c, x = sin(a) / c, z = (1 - cos(a)) / c. x runs across, z toward the
viewer, and the card turns by a about its upright middle. bend = 1 is Inside (the ring
curves toward the viewer), bend = -1 is Outside.
- Switching views eases bend from one to the other over 1100ms with cubic-bezier(0.65,
0, 0.35, 1), so the row visibly bends from one ring into the other.

2. The camera
- Perspective P is the eye's distance from the front card: P = mix(pIn, pOut, (1 - bend)
/ 2), so it moves with the switch. Defaults: pIn 860 (a little behind the ring's
center, so the row curves without pulling the side cards too far; at P = R the eye is
exactly at the center), pOut 1500 (well back, so the ring turns away gently).
- The eye looks straight on, at the cards' middle height. A point (x, y, z) lands on
screen at x * P / (P - z), y * P / (P - z), from the frame's center.
- Leave out a card when any part of it is less than 140 units in front of the eye, or
when it is wholly off the frame.
- Inside, the 22-card ring at pIn 860 shows five cards: three whole, the outer two going
into the glass. Outside it shows the whole ring, the far side between and beyond the
near cards.

3. The card face
- Corners: a continuous curve, a superellipse of exponent 4 over a 32px radius, the same
curve as CSS corner-shape: superellipse(2). In a shader, the distance to the outline
is: d = abs(p) - (w, h) / 2 + r; m = max(d, 0); dist = (m.x^4 + m.y^4)^(1/4) +
min(max(d.x, d.y), 0) - r.
- Front: a flowing gradient of four colors (section 4). Back: a picture, shown mirrored
so it reads the right way round when the card is turned.
- No shadow, no reflection, no darkening as cards turn away: on a white page they only
look dirty. Depth comes from size, blur and fade (section 6).
- Pressing a card shrinks it to 0.95 in 140ms and back in 320ms, about its middle.

4. The fluid gradient
- Value noise in fBm, 3 octaves; after each octave turn the point by the matrix (0.8,
-0.6; 0.6, 0.8), scale it by 2.02, add (1.7, 9.2), and halve the amplitude.
- With p the point on the card in pixels from its middle: uv = p / w * 0.9 + seed (seed
= i * 3.7 + 0.43, so every card differs).
- The flow moves the field around a circle: o1 = rho * (cos(phi), sin(phi)), o2 = rho *
(cos(phi + 2.1), sin(phi + 2.1)). phi grows with time so the field moves 0.2 noise
cells a second (the Flow slider, 20%); rho is the circle's radius. Because the field
comes back to where it began, a recording or a loop never jumps. In the demo one turn
takes the length of the animation loop (17.07s).
- Warp it twice: w1 = (fbm(uv + o1), fbm(uv + (5.2, 1.3) - o1)); w2 = (fbm(uv + 1.5 * w1
+ (1.7, 9.2) + o2), fbm(uv + 1.5 * w1 + (8.3, 2.8) - o2)); f = fbm(uv * 0.9 + 1.7 *
w2).
- Color: mix(c0, c1, smoothstep(0.3, 0.7, f)), then toward c2 by smoothstep(0.42, 0.72,
w2.x) * 0.9, then toward c3 by smoothstep(0.5, 0.8, w1.y) * 0.7; a soft light across
the top (toward white by smoothstep(0.1, -0.6, y / h) * 0.12); film grain of ±1.75%
that fades out under blur.
- Palettes, four colors each, one per card, for example: Tangerine #ff7a3d #ff3d77
#ffc46b #7a2cff; Lagoon #00c2c7 #2f6bff #9ff3e0 #0b2a6f; Peony #ff8fb1 #ffd1dc #b84dff
#ff5a5f; Citrus #ffe14d #7ee081 #ff9f1c #2ec4b6; Iris #6a5cff #b18cff #ff7ad9 #1b1464;
Aurora #2af598 #009efd #b3ffab #12123a. Or derive them from my brand colors and show
me.

5. Inside: the glass rim
- Draw the cards into a texture first, then lay it on screen in a second pass. Along
each side of the frame is a band of glass, rim = 160px wide.
- A pixel at distance d from its side (d < rim) shows the picture from further in: k =
(1 - d / rim)^2.4, and the offset is 0.4 * rim * k across, toward the middle, along
the line toward the eye point (so it also moves toward the eye's height). The cards'
top and bottom edges flare out under the glass, and the flare grows smoothly from
nothing at the band's inner side.
- Keep 0.4 * 2.4 under 1: the band then squeezes the picture toward the edge but never
folds it back on itself. A fold repeats a card, or a gap between cards, inside the
glass.
- Dispersion: take the offset at seven strengths, red bending furthest and blue least:
for t = i / 6, i = 0..6, the offset times 1 + spread * (1 - 2t), with spread = 0.25 *
k (the Dispersion slider, 25%). Weight each sample by w(t) = clamp((1.5 - 3t, 1 - 1.5
* |2t - 1|, 3t - 1.5), 0, 1) and divide by the summed weights, so the fringe runs
smoothly through the colors.
- A faint light along the glass: toward white by k^3 * 0.12.
- The rim belongs to Inside only: it fades out as bend goes to 0, and a 0 rim switches
it off.

6. Outside: depth of field
- Blur b, in screen pixels, is the larger of two: across the frame, blur *
smoothstep(110, half the frame's width, |screen x|)^1.4, so the middle 220px stays
sharp and the blur grows smoothly toward the sides; and with distance, blur *
smoothstep(0.25, 0.8, back)^1.2, where back = -z / (2R) goes from 0 at the front card
to 1 at the far side. Default blur 14px.
- Work the blur out per pixel, never with a backdrop blur over moving content (it
shimmers). For a card, take its coverage as a box blur in screen pixels, separately
across and up: across = clamp((min(dl, b) + min(dr, b)) / (2b), 0, 1), where dl and dr
are the screen distances to the card's left and right sides; the same for up and down;
alpha = smoothstep(across) * smoothstep(down), capped by the corners softened by the
same b. A card narrower than the blur never reaches full cover and fades, as a real
blur would.
- Draw each card with a margin of (the largest blur + 4) screen pixels around it, so a
blurred edge always has room, however steeply the card is turned.
- Blur the content too: fade out the noise octaves finer than the blur, and read the
pictures from a smaller mipmap level, log2(max(1, b * texels per screen pixel)).
- The far side fades toward the page: toward white by fade * smoothstep(0.3, 1, back).
Default fade 50%.

7. Turning over, and motion
- Switching to Outside turns every card over about its upright middle, one after another
from the front card out: for the whole run flip going 0 to 1 over 1800ms with
cubic-bezier(0.3, 0, 0.6, 1), each card's lag = min(|s| / (6 * step), 1) and its turn
= PI * smoothstep(0, 1, flip * 1.55 - lag * 0.55). The front half ends showing
pictures and the far half its gradients. Switching back turns them back.
- Drag: the row follows the pointer one pixel for one pixel. On release it glides on
with the release speed (target = offset - velocity * 260ms), snaps to the nearest
card, and takes clamp(|distance| * 1.6, 420, 1100) ms with cubic-bezier(0.25, 0.6,
0.2, 1). Pressing a card brings it to the front in 760ms.
- A hard flick, fast then slow (used to open Inside): 16 cards in 2800ms with
cubic-bezier(0.4, 0, 0.12, 1). It picks up speed in a moment rather than jumping to
full speed, so a loop that begins with it has no jolt.
- Any new motion stops the one before it. Reduced motion: no flow, an instant switch,
slides of 200ms at most.

8. The settings panel
- One row per number: its name, a slider and its value with the unit. The rows change
with the view. Moving a slider updates the picture at once and stops any demo
animation. A reset puts every value back to its default.
- Inside: Perspective 860px (600 to 1400), Glass rim 160px (0 to 240), Dispersion 25% (0
to 60), Flow 20% (0 to 60), Corner 32px (0 to 60).
- Outside: Perspective 1500px (900 to 2400), Depth blur 14px (0 to 30), Far fade 50% (0
to 100), Flow 20%, Corner 32px.
- Use my slider component if I have one; otherwise a plain range input with a filled
track, an upright handle and a number box beside it.
- Changing Flow adds to the flow's angle each frame instead of multiplying time, so the
gradients never jump.

9. How to build it, by platform
These are suggestions; check them against my stack and versions.
- Web (as in the demo): WebGL 2, two passes. Each card is one strip of upright columns
(96 across, plus one past each side for the margin) placed in the vertex shader;
upright lines stay straight under the perspective, so a top and a bottom point per
column are enough. The pictures go in one texture array with mipmaps. Draw the cards
farthest first with premultiplied alpha into a texture, then the glass pass to the
screen. Run one requestAnimationFrame loop; at 2x pixel density it holds 60 fps on a
laptop.
- iOS: Metal (MTKView) with the same two passes, or SwiftUI with a Metal [[stitchable]]
layerEffect for the glass pass and visualEffect for the cards.
- Android: OpenGL ES 3 or Vulkan; on API 33+ an AGSL RuntimeShader can draw the gradient
and the glass pass in Compose.
- Flutter: FragmentProgram shaders for the gradient and the glass pass, the cards in a
CustomPainter with drawVertices.
- If the platform has no GPU path: CSS 3D transforms can place the cards (preserve-3d,
the same x, z and a), with CSS gradients standing in for the fluid; leave out the
glass pass and use a few stepped blur layers per card instead of the per-pixel blur.

10. Check
- Inside: the outer cards flare smoothly in the glass with a soft color fringe, no fold,
no repeated card; five cards in view.
- Outside: reads as a ring at eye level; the middle is sharp, the blur grows smoothly to
the sides and the far side, with no shimmer while the ring turns and no hard edge on a
steeply turned card.
- The turn-over runs from the middle out; the pictures read the right way round; the far
side shows gradients.
- Every slider changes the picture at once, the values match section 8, and reset
restores them.
- 60 fps on a mid-range phone; reduced motion, light and dark pages, and keyboard use of
the panel all checked.

质感来自可解释的细节

这类效果最容易犯的错,是把“空间感”理解成“多加特效”:加阴影、加反光、加发光、加模糊,最后每张卡片都很漂亮,但不在同一个空间里。

真正让它成立的,是所有部分都服从同一台摄像机:卡片的弧线由曲率决定,透视由摄像机距离决定,玻璃边只折射环内视角,景深只发生在环外,翻面和拖拽都围绕同一套位置关系。关系一致之后,用户看到的才是一只环,而不是 22 张各自表演的卡片。

原推文:正文 · Prompt

站内搜索

没有找到内容!